#!/usr/bin/env python
# -*- coding: utf-8 -*-

import base64
import hashlib
import hmac
import struct
import sys
import os
from pathlib import Path
import io
import binascii
import time
import random

# 简化导入方式
try:
    # 先尝试直接导入
    from java_rc4 import process_with_key
except ImportError:
    # 如果直接导入失败，尝试从当前目录导入
    from .java_rc4 import process_with_key

# 获取当前文件所在目录
current_dir = Path(__file__).parent
# 将当前目录添加到sys.path
sys.path.append(str(current_dir))

def java_string_hash(s):
    """
    实现Java中的字符串哈希算法
    public static int a(String str) {
        if (str.length() <= 0) {
            return 0;
        }
        int i2 = 0;
        for (char c2 : str.toCharArray()) {
            i2 = (i2 * 31) + c2;
        }
        return i2;
    }
    """
    if not s or len(s) <= 0:
        return 0
    
    hash_value = 0
    for c in s:
        hash_value = (hash_value * 31) + ord(c)
        # 模拟Java中的int溢出
        hash_value = hash_value & 0xFFFFFFFF
        if hash_value & 0x80000000:
            hash_value = hash_value - 0x100000000
    
    return hash_value

def java_hmac_sha1(data_bytes):
    """
    模拟Java的HMAC-SHA1实现
    
    Args:
        data_bytes: 要计算HMAC的字节数据
        
    Returns:
        bytes: HMAC结果
    """
    # 与Java代码中相同的密钥字节数组
    # 将Java中的负数转换为Python中的无符号字节
    # 对应Java代码: byte[] bArr2 = {69, 114, 116, -33, 125, -54, ExifInterface.MARKER_APP1, 86, -11, 11, -78, -96, -17, -99, 64, 23, -95, -126, -82, -64, 113, 116, -16, -103, 49, -30, 9, ExifInterface.MARKER_EOI, 33, -80, -68, -78, -117, 53, 30, -122, 64, -104, 74, -49, 106, 85, -38, -93};
    # ExifInterface.MARKER_APP1 = -31, ExifInterface.MARKER_EOI = -39
    key_bytes = bytes([
        69, 114, 116, 223, 125, 202, 225, 86, 245, 11, 178, 160, 239, 157, 64, 23, 
        161, 130, 174, 192, 113, 116, 240, 153, 49, 226, 9, 217, 33, 176, 188, 178, 
        139, 53, 30, 134, 64, 152, 74, 207, 106, 85, 218, 163
    ])
    
    # 使用RC4处理密钥 - 对应Java代码: g.b(bArr2)
    processed_key = process_with_key(key_bytes)
    
    # 使用处理后的密钥计算HMAC - 对应Java代码: mac.doFinal(bArr)
    h = hmac.new(processed_key, data_bytes, hashlib.sha1)
    return h.digest()

def calculate_hmac_hash(timestamp, random_int, device_hash):
    """
    按照Java实现计算HMAC哈希
    
    Args:
        timestamp: 时间戳
        random_int: 随机数
        device_hash: 设备哈希
        
    Returns:
        int: HMAC哈希值（32位有符号整数）
    """
    # 创建ByteArrayOutputStream
    buffer = io.BytesIO()
    
    # 写入时间戳（4字节）
    buffer.write(struct.pack(">I", timestamp))
    
    # 写入随机数（4字节）
    buffer.write(struct.pack(">i", random_int))
    
    # 写入版本号（1字节）
    buffer.write(struct.pack("B", 3))
    
    # 写入补充字节（1字节）
    buffer.write(struct.pack("B", 0))
    
    # 写入设备哈希（4字节）
    buffer.write(struct.pack(">i", device_hash))
    
    # 获取当前已写入的所有字节
    data = buffer.getvalue()
    
    # 计算HMAC
    hmac_result = java_hmac_sha1(data)
    
    # 将HMAC结果进行Base64编码 - 对应Java代码: com.ta.utdid2.a.a.b.encodeToString(mac.doFinal(bArr), 2)
    b64_str = base64.b64encode(hmac_result).decode('utf-8')
    
    # 对Base64编码后的字符串应用字符串哈希函数 - 对应Java代码: com.ta.utdid2.a.a.f.a()
    hmac_hash = java_string_hash(b64_str)
    
    return hmac_hash

def parse_utdid(utdid):
    """
    解析UTDID，获取其组件
    
    Args:
        utdid: UTDID字符串
        
    Returns:
        tuple: (timestamp, random_int, version, supplement, device_hash, hmac_hash)
    """
    try:
        decoded = base64.b64decode(utdid)
        timestamp = struct.unpack(">I", decoded[0:4])[0]
        random_int = struct.unpack(">i", decoded[4:8])[0]
        version = decoded[8]
        supplement = decoded[9]
        device_hash = struct.unpack(">i", decoded[10:14])[0]
        hmac_hash = struct.unpack(">i", decoded[14:18])[0]
        
        return timestamp, random_int, version, supplement, device_hash, hmac_hash
    except Exception as e:
        print(f"解析UTDID失败: {e}")
        return None

def create_device_id(android_id):
    """
    根据Android ID创建设备ID
    
    Args:
        android_id: Android ID字符串
        
    Returns:
        str: 生成的设备ID
    """
    # 计算设备哈希
    device_hash = java_string_hash(android_id)
    
    # 使用当前时间戳
    timestamp = int(time.time())
    
    # 生成随机数
    random_int = random.randint(-2147483648, 2147483647)
    
    # 计算HMAC哈希
    hmac_hash = calculate_hmac_hash(timestamp, random_int, device_hash)
    
    # 直接生成UTDID，不再调用create_custom_utdid
    # 创建ByteArrayOutputStream
    buffer = io.BytesIO()
    
    # 写入时间戳（4字节）
    buffer.write(struct.pack(">I", timestamp))
    
    # 写入随机数（4字节）
    buffer.write(struct.pack(">i", random_int))
    
    # 写入版本号（1字节）
    buffer.write(struct.pack("B", 3))
    
    # 写入补充字节（1字节）
    buffer.write(struct.pack("B", 0))
    
    # 写入设备哈希（4字节）
    buffer.write(struct.pack(">i", device_hash))
    
    # 写入HMAC哈希（4字节）
    buffer.write(struct.pack(">i", hmac_hash))
    
    # 获取所有字节
    data = buffer.getvalue()
    
    # Base64编码
    device_id = base64.b64encode(data).decode('utf-8')
    
    return device_id

if __name__ == "__main__":
    # 目标UTDID
    target_utdid = "Z+Y6b2IPUIgDAPCT+TR/1bNK"
    
    # 解析目标UTDID
    components = parse_utdid(target_utdid)
    if components:
        timestamp, random_int, version, supplement, device_hash, hmac_hash = components
        print("目标UTDID解码:")
        print(f"  时间戳: {timestamp}")
        print(f"  随机数: {random_int}")
        print(f"  版本: {version}")
        print(f"  补充字节: {supplement}")
        print(f"  设备哈希: {device_hash}")
        print(f"  HMAC哈希: {hmac_hash}")
        print()
        
        # 计算设备哈希
        android_id = "61a1a2bd31bf66a5"
        calculated_device_hash = java_string_hash(android_id)
        print(f"Android ID: {android_id}")
        print(f"计算的设备哈希: {calculated_device_hash}")
        print()
        
        # 计算HMAC哈希
        calculated_hmac_hash = calculate_hmac_hash(timestamp, random_int, device_hash)
        print(f"计算的HMAC哈希: {calculated_hmac_hash}")
        print(f"与目标匹配: {calculated_hmac_hash == hmac_hash}")
        print()
        

        
        # 测试使用真实Android ID
        real_android_id = "d72fe7cc28264af0"  # 真实设备的Android ID
        real_device_id = create_device_id(real_android_id)
        print(f"\n使用真实Android ID: {real_android_id}")
        print(f"生成的设备ID: {real_device_id}")
        
        # 解析新生成的设备ID
        new_components = parse_utdid(real_device_id)
        if new_components:
            new_timestamp, new_random_int, new_version, new_supplement, new_device_hash, new_hmac_hash = new_components
            print("新设备ID解码:")
            print(f"  时间戳: {new_timestamp}")
            print(f"  随机数: {new_random_int}")
            print(f"  版本: {new_version}")
            print(f"  补充字节: {new_supplement}")
            print(f"  设备哈希: {new_device_hash}")
            print(f"  HMAC哈希: {new_hmac_hash}")
